package com.aizuda.boot.modules.common.constant.enums;

import io.swagger.v3.oas.annotations.media.Schema;
import lombok.AllArgsConstructor;
import lombok.Getter;

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

/**
 * 合同编号生成规则组件类型枚举
 * @Author sangyirong
 * @ClassName ComponentTypeEnums
 * @Version 1.0
 * @Date 2025/6/27 18:34
 */
@Getter
@AllArgsConstructor
@Schema(description = "组件类型")
public enum ComponentTypeEnums {

    /**
     * 自由文本 - 适用于所有规则类型
     */
    FREE_TEXT("FREE_TEXT", "自由文本", null, 
        Arrays.asList(RuleTypeEnums.CONTRACT_APPLY, RuleTypeEnums.CONTRACT_CHANGE, 
                      RuleTypeEnums.CONTRACT_TERMINATE, RuleTypeEnums.CONTRACT_GROUP)),

    /**
     * 日期 - 适用于所有规则类型
     */
    DATE("DATE", "日期", Arrays.asList("yyyyMMdd", "yyyyMM", "yyyy"), 
        Arrays.asList(RuleTypeEnums.CONTRACT_APPLY, RuleTypeEnums.CONTRACT_CHANGE, 
                      RuleTypeEnums.CONTRACT_TERMINATE, RuleTypeEnums.CONTRACT_GROUP)),

    /**
     * 合同类型编号 - 适用于所有规则类型
     */
    CONTRACT_TYPE("CONTRACT_TYPE", "合同类型编号", null, 
        Arrays.asList(RuleTypeEnums.CONTRACT_APPLY)),

    /**
     * 连接符 - 适用于所有规则类型
     */
    SEPARATOR("SEPARATOR", "连接符", Arrays.asList("-", "/", ".", "_"), 
        Arrays.asList(RuleTypeEnums.CONTRACT_APPLY, RuleTypeEnums.CONTRACT_CHANGE, 
                      RuleTypeEnums.CONTRACT_TERMINATE, RuleTypeEnums.CONTRACT_GROUP)),

    /**
     * 我方主体简称 - 适用于所有规则类型
     */
    OUR_PARTY("OUR_PARTY", "我方主体简称", null, 
        Arrays.asList(RuleTypeEnums.CONTRACT_APPLY, RuleTypeEnums.CONTRACT_CHANGE, 
                      RuleTypeEnums.CONTRACT_TERMINATE, RuleTypeEnums.CONTRACT_GROUP)),

    /**
     * 收支类型 - 适用于所有规则类型
     */
    DOCUMENT_TYPE("DOCUMENT_TYPE", "收支类型", null, 
        Arrays.asList(RuleTypeEnums.CONTRACT_APPLY, RuleTypeEnums.CONTRACT_GROUP)),

    /**
     * 自动序号 - 适用于所有规则类型
     */
    AUTO_INCREMENT("AUTO_INCREMENT", "自动序号", Arrays.asList("1", "2", "3", "4", "5", "6"), 
        Arrays.asList(RuleTypeEnums.CONTRACT_APPLY, RuleTypeEnums.CONTRACT_CHANGE, 
                      RuleTypeEnums.CONTRACT_TERMINATE, RuleTypeEnums.CONTRACT_GROUP)),

    /**
     * 引用规则 - 适用于所有规则类型
     */
    RULE_REFERENCE("RULE_REFERENCE", "引用规则", null, 
        Arrays.asList(RuleTypeEnums.CONTRACT_CHANGE, RuleTypeEnums.CONTRACT_TERMINATE));

    /**
     * 组件编码
     */
    private final String code;

    /**
     * 组件描述
     */
    private final String msg;

    /**
     * 组件可选值列表（如果为null表示自由输入）
     */
    private final List<String> values;

    /**
     * 适用的规则类型列表
     */
    private final List<RuleTypeEnums> ruleTypes;

    /**
     * 根据规则类型获取适用的组件类型列表
     * @param ruleType 规则类型
     * @return 适用的组件类型列表
     */
    public static List<ComponentTypeEnums> getComponentsByRuleType(RuleTypeEnums ruleType) {
        if (ruleType == null) {
            return Arrays.asList(values());
        }
        
        return Arrays.stream(values())
                .filter(component -> component.getRuleTypes().contains(ruleType))
                .collect(Collectors.toList());
    }

    /**
     * 获取所有通用组件（适用于所有规则类型的组件）
     * @return 通用组件列表
     */
    public static List<ComponentTypeEnums> getUniversalComponents() {
        return Arrays.stream(values())
                .filter(component -> component.getRuleTypes().size() == 4)
                .collect(Collectors.toList());
    }

    /**
     * 获取特定规则类型专用的组件
     * @param ruleType 规则类型
     * @return 专用组件列表
     */
    public static List<ComponentTypeEnums> getExclusiveComponents(RuleTypeEnums ruleType) {
        if (ruleType == null) {
            return Arrays.asList();
        }
        
        return Arrays.stream(values())
                .filter(component -> component.getRuleTypes().size() == 1 
                    && component.getRuleTypes().contains(ruleType))
                .collect(Collectors.toList());
    }
}
